home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 21 / AACD 21.iso / AACD / Utilities / Ghostscript / src / gdevmr8n.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-01-01  |  10.8 KB  |  377 lines
  1. /* Copyright (C) 1995, 1996, 1997, 1998, 1999 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of AFPL Ghostscript.
  4.   
  5.   AFPL Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author or
  6.   distributor accepts any responsibility for the consequences of using it, or
  7.   for whether it serves any particular purpose or works at all, unless he or
  8.   she says so in writing.  Refer to the Aladdin Free Public License (the
  9.   "License") for full details.
  10.   
  11.   Every copy of AFPL Ghostscript must include a copy of the License, normally
  12.   in a plain ASCII text file named PUBLIC.  The License grants you the right
  13.   to copy, modify and redistribute AFPL Ghostscript, but only under certain
  14.   conditions described in the License.  Among other things, the License
  15.   requires that the copyright notice and this notice be preserved on all
  16.   copies.
  17. */
  18.  
  19. /*$Id: gdevmr8n.c,v 1.2 2000/09/19 19:00:14 lpd Exp $ */
  20. /* RasterOp implementation for 8N-bit memory devices */
  21. #include "memory_.h"
  22. #include "gx.h"
  23. #include "gsbittab.h"
  24. #include "gserrors.h"
  25. #include "gsropt.h"
  26. #include "gxcindex.h"
  27. #include "gxdcolor.h"
  28. #include "gxdevice.h"
  29. #include "gxdevmem.h"
  30. #include "gxdevrop.h"
  31. #include "gdevmem.h"
  32. #include "gdevmrop.h"
  33.  
  34. /*
  35.  * NOTE: The 16- and 32-bit cases aren't implemented: they just fall back to
  36.  * the default implementation.  This is very slow and will be fixed someday.
  37.  */
  38.  
  39. #define chunk byte
  40.  
  41. /* Calculate the X offset for a given Y value, */
  42. /* taking shift into account if necessary. */
  43. #define x_offset(px, ty, textures)\
  44.   ((textures)->shift == 0 ? (px) :\
  45.    (px) + (ty) / (textures)->rep_height * (textures)->rep_shift)
  46.  
  47. /* ---------------- RasterOp with 8-bit gray / 24-bit RGB ---------------- */
  48.  
  49. int
  50. mem_gray8_rgb24_strip_copy_rop(gx_device * dev,
  51.          const byte * sdata, int sourcex, uint sraster, gx_bitmap_id id,
  52.                    const gx_color_index * scolors,
  53.        const gx_strip_bitmap * textures, const gx_color_index * tcolors,
  54.                    int x, int y, int width, int height,
  55.                int phase_x, int phase_y, gs_logical_operation_t lop)
  56. {
  57.     gx_device_memory *mdev = (gx_device_memory *) dev;
  58.     gs_rop3_t rop = lop_rop(lop);
  59.     gx_color_index const_source = gx_no_color_index;
  60.     gx_color_index const_texture = gx_no_color_index;
  61.     uint draster = mdev->raster;
  62.     int line_count;
  63.     byte *drow;
  64.     int depth = dev->color_info.depth;
  65.     int bpp = depth >> 3;    /* bytes per pixel, 1 or 3 */
  66.     gx_color_index all_ones = ((gx_color_index) 1 << depth) - 1;
  67.     gx_color_index strans =
  68.     (lop & lop_S_transparent ? all_ones : gx_no_color_index);
  69.     gx_color_index ttrans =
  70.     (lop & lop_T_transparent ? all_ones : gx_no_color_index);
  71.  
  72.     /* Check for constant source. */
  73.     if (!rop3_uses_S(rop))
  74.     const_source = 0;    /* arbitrary */
  75.     else if (scolors != 0 && scolors[0] == scolors[1]) {
  76.     /* Constant source */
  77.     const_source = scolors[0];
  78.     if (const_source == gx_device_black(dev))
  79.         rop = rop3_know_S_0(rop);
  80.     else if (const_source == gx_device_white(dev))
  81.         rop = rop3_know_S_1(rop);
  82.     }
  83.  
  84.     /* Check for constant texture. */
  85.     if (!rop3_uses_T(rop))
  86.     const_texture = 0;    /* arbitrary */
  87.     else if (tcolors != 0 && tcolors[0] == tcolors[1]) {
  88.     /* Constant texture */
  89.     const_texture = tcolors[0];
  90.     if (const_texture == gx_device_black(dev))
  91.         rop = rop3_know_T_0(rop);
  92.     else if (const_texture == gx_device_white(dev))
  93.         rop = rop3_know_T_1(rop);
  94.     }
  95.  
  96.     if (bpp == 1 &&
  97.     (gx_device_has_color(dev) ||
  98.      (gx_device_black(dev) != 0 || gx_device_white(dev) != all_ones))
  99.     ) {
  100.     /*
  101.      * This is an 8-bit device but not gray-scale.  Except in a few
  102.      * simple cases, we have to use the slow algorithm that converts
  103.      * values to and from RGB.
  104.      */
  105.     gx_color_index bw_pixel;
  106.  
  107.     switch (rop) {
  108.     case rop3_0:
  109.         bw_pixel = gx_device_black(dev);
  110.         goto bw;
  111.     case rop3_1:
  112.         bw_pixel = gx_device_white(dev);
  113. bw:        if (bw_pixel == 0x00)
  114.         rop = rop3_0;
  115.         else if (bw_pixel == 0xff)
  116.         rop = rop3_1;
  117.         else
  118.         goto df;
  119.         break;
  120.     case rop3_D:
  121.         break;
  122.     case rop3_S:
  123.         if (lop & lop_S_transparent)
  124.         goto df;
  125.         break;
  126.     case rop3_T:
  127.         if (lop & lop_T_transparent)
  128.         goto df;
  129.         break;
  130.     default:
  131. df:        return mem_default_strip_copy_rop(dev,
  132.                           sdata, sourcex, sraster, id,
  133.                           scolors, textures, tcolors,
  134.                           x, y, width, height,
  135.                           phase_x, phase_y, lop);
  136.     }
  137.     }
  138.  
  139.     /* Adjust coordinates to be in bounds. */
  140.     if (const_source == gx_no_color_index) {
  141.     fit_copy(dev, sdata, sourcex, sraster, id,
  142.          x, y, width, height);
  143.     } else {
  144.     fit_fill(dev, x, y, width, height);
  145.     }
  146.  
  147.     /* Set up transfer parameters. */
  148.     line_count = height;
  149.     drow = scan_line_base(mdev, y) + x * bpp;
  150.  
  151.     /*
  152.      * There are 18 cases depending on whether each of the source and
  153.      * texture is constant, 1-bit, or multi-bit, and on whether the
  154.      * depth is 8 or 24 bits.  We divide first according to constant
  155.      * vs. non-constant, and then according to 1- vs. multi-bit, and
  156.      * finally according to pixel depth.  This minimizes source code,
  157.      * but not necessarily time, since we do some of the divisions
  158.      * within 1 or 2 levels of loop.
  159.      */
  160.  
  161. #define dbit(base, i) ((base)[(i) >> 3] & (0x80 >> ((i) & 7)))
  162. /* 8-bit */
  163. #define cbit8(base, i, colors)\
  164.   (dbit(base, i) ? (byte)colors[1] : (byte)colors[0])
  165. #define rop_body_8(s_pixel, t_pixel)\
  166.   if ( (s_pixel) == strans ||    /* So = 0, s_tr = 1 */\
  167.        (t_pixel) == ttrans    /* Po = 0, p_tr = 1 */\
  168.      )\
  169.     continue;\
  170.   *dptr = (*rop_proc_table[rop])(*dptr, s_pixel, t_pixel)
  171. /* 24-bit */
  172. #define get24(ptr)\
  173.   (((gx_color_index)(ptr)[0] << 16) | ((gx_color_index)(ptr)[1] << 8) | (ptr)[2])
  174. #define put24(ptr, pixel)\
  175.   (ptr)[0] = (byte)((pixel) >> 16),\
  176.   (ptr)[1] = (byte)((uint)(pixel) >> 8),\
  177.   (ptr)[2] = (byte)(pixel)
  178. #define cbit24(base, i, colors)\
  179.   (dbit(base, i) ? colors[1] : colors[0])
  180. #define rop_body_24(s_pixel, t_pixel)\
  181.   if ( (s_pixel) == strans ||    /* So = 0, s_tr = 1 */\
  182.        (t_pixel) == ttrans    /* Po = 0, p_tr = 1 */\
  183.      )\
  184.     continue;\
  185.   { gx_color_index d_pixel = get24(dptr);\
  186.     d_pixel = (*rop_proc_table[rop])(d_pixel, s_pixel, t_pixel);\
  187.     put24(dptr, d_pixel);\
  188.   }
  189.  
  190.     if (const_texture != gx_no_color_index) {
  191. /**** Constant texture ****/
  192.     if (const_source != gx_no_color_index) {
  193. /**** Constant source & texture ****/
  194.         for (; line_count-- > 0; drow += draster) {
  195.         byte *dptr = drow;
  196.         int left = width;
  197.  
  198.         if (bpp == 1)
  199. /**** 8-bit destination ****/
  200.             for (; left > 0; ++dptr, --left) {
  201.             rop_body_8((byte)const_source, (byte)const_texture);
  202.             }
  203.         else
  204. /**** 24-bit destination ****/
  205.             for (; left > 0; dptr += 3, --left) {
  206.             rop_body_24(const_source, const_texture);
  207.             }
  208.         }
  209.     } else {
  210. /**** Data source, const texture ****/
  211.         const byte *srow = sdata;
  212.  
  213.         for (; line_count-- > 0; drow += draster, srow += sraster) {
  214.         byte *dptr = drow;
  215.         int left = width;
  216.  
  217.         if (scolors) {
  218. /**** 1-bit source ****/
  219.             int sx = sourcex;
  220.  
  221.             if (bpp == 1)
  222. /**** 8-bit destination ****/
  223.             for (; left > 0; ++dptr, ++sx, --left) {
  224.                 byte s_pixel = cbit8(srow, sx, scolors);
  225.  
  226.                 rop_body_8(s_pixel, (byte)const_texture);
  227.             }
  228.             else
  229. /**** 24-bit destination ****/
  230.             for (; left > 0; dptr += 3, ++sx, --left) {
  231.                 bits32 s_pixel = cbit24(srow, sx, scolors);
  232.  
  233.                 rop_body_24(s_pixel, const_texture);
  234.             }
  235.         } else if (bpp == 1) {
  236. /**** 8-bit source & dest ****/
  237.             const byte *sptr = srow + sourcex;
  238.  
  239.             for (; left > 0; ++dptr, ++sptr, --left) {
  240.             byte s_pixel = *sptr;
  241.  
  242.             rop_body_8(s_pixel, (byte)const_texture);
  243.             }
  244.         } else {
  245. /**** 24-bit source & dest ****/
  246.             const byte *sptr = srow + sourcex * 3;
  247.  
  248.             for (; left > 0; dptr += 3, sptr += 3, --left) {
  249.             bits32 s_pixel = get24(sptr);
  250.  
  251.             rop_body_24(s_pixel, const_texture);
  252.             }
  253.         }
  254.         }
  255.     }
  256.     } else if (const_source != gx_no_color_index) {
  257. /**** Const source, data texture ****/
  258.     uint traster = textures->raster;
  259.     int ty = y + phase_y;
  260.  
  261.     for (; line_count-- > 0; drow += draster, ++ty) {    /* Loop over copies of the tile. */
  262.         int dx = x, w = width, nw;
  263.         byte *dptr = drow;
  264.         const byte *trow =
  265.         textures->data + (ty % textures->size.y) * traster;
  266.         int xoff = x_offset(phase_x, ty, textures);
  267.  
  268.         for (; w > 0; dx += nw, w -= nw) {
  269.         int tx = (dx + xoff) % textures->rep_width;
  270.         int left = nw = min(w, textures->size.x - tx);
  271.         const byte *tptr = trow;
  272.  
  273.         if (tcolors) {
  274. /**** 1-bit texture ****/
  275.             if (bpp == 1)
  276. /**** 8-bit dest ****/
  277.             for (; left > 0; ++dptr, ++tx, --left) {
  278.                 byte t_pixel = cbit8(tptr, tx, tcolors);
  279.  
  280.                 rop_body_8((byte)const_source, t_pixel);
  281.             }
  282.             else
  283. /**** 24-bit dest ****/
  284.             for (; left > 0; dptr += 3, ++tx, --left) {
  285.                 bits32 t_pixel = cbit24(tptr, tx, tcolors);
  286.  
  287.                 rop_body_24(const_source, t_pixel);
  288.             }
  289.         } else if (bpp == 1) {
  290. /**** 8-bit T & D ****/
  291.             tptr += tx;
  292.             for (; left > 0; ++dptr, ++tptr, --left) {
  293.             byte t_pixel = *tptr;
  294.  
  295.             rop_body_8((byte)const_source, t_pixel);
  296.             }
  297.         } else {
  298. /**** 24-bit T & D ****/
  299.             tptr += tx * 3;
  300.             for (; left > 0; dptr += 3, tptr += 3, --left) {
  301.             bits32 t_pixel = get24(tptr);
  302.  
  303.             rop_body_24(const_source, t_pixel);
  304.             }
  305.         }
  306.         }
  307.     }
  308.     } else {
  309. /**** Data source & texture ****/
  310.     uint traster = textures->raster;
  311.     int ty = y + phase_y;
  312.     const byte *srow = sdata;
  313.  
  314.     /* Loop over scan lines. */
  315.     for (; line_count-- > 0; drow += draster, srow += sraster, ++ty) {    /* Loop over copies of the tile. */
  316.         int sx = sourcex;
  317.         int dx = x;
  318.         int w = width;
  319.         int nw;
  320.         byte *dptr = drow;
  321.         const byte *trow =
  322.         textures->data + (ty % textures->size.y) * traster;
  323.         int xoff = x_offset(phase_x, ty, textures);
  324.  
  325.         for (; w > 0; dx += nw, w -= nw) {    /* Loop over individual pixels. */
  326.         int tx = (dx + xoff) % textures->rep_width;
  327.         int left = nw = min(w, textures->size.x - tx);
  328.         const byte *tptr = trow;
  329.  
  330.         /*
  331.          * For maximum speed, we should split this loop
  332.          * into 7 cases depending on source & texture
  333.          * depth: (1,1), (1,8), (1,24), (8,1), (8,8),
  334.          * (24,1), (24,24).  But since we expect these
  335.          * cases to be relatively uncommon, we just
  336.          * divide on the destination depth.
  337.          */
  338.         if (bpp == 1) {
  339. /**** 8-bit destination ****/
  340.             const byte *sptr = srow + sx;
  341.  
  342.             tptr += tx;
  343.             for (; left > 0; ++dptr, ++sptr, ++tptr, ++sx, ++tx, --left) {
  344.             byte s_pixel =
  345.                 (scolors ? cbit8(srow, sx, scolors) : *sptr);
  346.             byte t_pixel =
  347.                 (tcolors ? cbit8(tptr, tx, tcolors) : *tptr);
  348.  
  349.             rop_body_8(s_pixel, t_pixel);
  350.             }
  351.         } else {
  352. /**** 24-bit destination ****/
  353.             const byte *sptr = srow + sx * 3;
  354.  
  355.             tptr += tx * 3;
  356.             for (; left > 0; dptr += 3, sptr += 3, tptr += 3, ++sx, ++tx, --left) {
  357.             bits32 s_pixel =
  358.                 (scolors ? cbit24(srow, sx, scolors) :
  359.                  get24(sptr));
  360.             bits32 t_pixel =
  361.                 (tcolors ? cbit24(tptr, tx, tcolors) :
  362.                  get24(tptr));
  363.  
  364.             rop_body_24(s_pixel, t_pixel);
  365.             }
  366.         }
  367.         }
  368.     }
  369.     }
  370. #undef rop_body_8
  371. #undef rop_body_24
  372. #undef dbit
  373. #undef cbit8
  374. #undef cbit24
  375.     return 0;
  376. }
  377.